////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2017-2018 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// THIS IS AUTO-GENERATED CODE.  PLEASE DO NOT EDIT (File bug reports against tools).
///
/// Auto-generated by: ParameterParser V1.1.4
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  afpdlibelements.h
/// @brief Auto-generated Chromatix parameter file
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef AFPDLIBELEMENTS_H
#define AFPDLIBELEMENTS_H

#include "parametermodule.h"
#include "parameterfilesymboltable.h"
#include "parametertypes.h"
#include "afglobalelements.h"

#define AFPDLIBELEMENTS_NAMESPACE_BEGIN namespace afpdlibelements {
#define AFPDLIBELEMENTS_NAMESPACE_END }

AFPDLIBELEMENTS_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDProcessingMode
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class chromatixPDProcessingMode
{
    PD_PROCESSING_MODE_DYNAMIC = 0,
    PD_PROCESSING_MODE_LOW     = 1,
    PD_PROCESSING_MODE_MED     = 2,
    PD_PROCESSING_MODE_HIGH    = 3
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixTuningProcessLevel
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixTuningProcessLevel
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// processingMode
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixPDProcessingMode processingMode;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// dynamicLevel
    ///
    /// Description:   Tuning parameter for dynamic adjustment of vertical density at which PD is computed.
    /// Range:         [50,200]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                     dynamicLevel;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixTuningAdaptiveK
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixTuningAdaptiveK
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enable
    ///
    /// Description:   A flag for enabling adaptive k feature or not.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type enable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// timeoutFrameCntThres
    ///
    /// Description:   A timeout frame number. If frame counter meets the threshold as adaptive k is in state 1, it will return
    ///                to state 0.
    /// Range:         [1,255]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            timeoutFrameCntThres;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// filterSize
    ///
    /// Description:   Size of the median filter. The median filter process is utilized as estimating DCC value from adaptive k
    ///                data history.
    /// Range:         [1,9]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            filterSize;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// state0StableCntThres
    ///
    /// Description:   Stable count threshold as adaptive k is in state 0. Before entering state 1, all adaptive k input stats
    ///                should meet state-0-requirements for at least state0StableCntThres frames.
    /// Range:         [1,255]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            state0StableCntThres;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// state1StableCntThres
    ///
    /// Description:   Stable count threshold as adaptive k is in state 1. Before entering state 2, all adaptive k input stats
    ///                should meet state-2-requirements for at least state1StableCntThres frames.
    /// Range:         [1,255]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            state1StableCntThres;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// minimumLensPosDelta
    ///
    /// Description:   Minimum number of lens position delta as estimating K value in state 2. If the lens position delta is
    ///                less than the value, the K estimate will be abandoned.
    /// Range:         [1,400]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            minimumLensPosDelta;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// state0ConfThres
    ///
    /// Description:   Minimum confidence value before entering state 1 as adaptive k is in state 0.
    /// Range:         [1,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            state0ConfThres;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// state1ConfThres
    ///
    /// Description:   Minimum confidence value before entering state 2 as adaptive k is in state 1.
    /// Range:         [1,1024]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            state1ConfThres;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// state0PhaseDiffThres
    ///
    /// Description:   Minimum phase difference value before entering state 1 as adaptive k is in state 0.
    /// Range:         [0,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            state0PhaseDiffThres;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// state1PhaseDiffThres
    ///
    /// Description:   Minimum phase difference value before entering state 2 as adaptive k is in state 1.
    /// Range:         [0,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            state1PhaseDiffThres;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// tolNearTargetUpperBound
    ///
    /// Description:   Upper bound ratio with respect to golden module K value as target is at near end (MACRO). If estimated K
    ///                is within the bound, this means K value is valid for proper AF behavior.
    /// Range:         [0,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            tolNearTargetUpperBound;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// tolNearTargetLowerBound
    ///
    /// Description:   Lower bound ratio with respect to golden module K value as target is at near end (MACRO). If estimated K
    ///                is within the bound, this means K value is valid for proper AF behavior.
    /// Range:         [0,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            tolNearTargetLowerBound;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// tolFarTargetUpperBound
    ///
    /// Description:   Upper bound ratio with respect to golden module K value as target is at far end (INFINITY). If estimated
    ///                K is within the bound, this means K value is valid for proper AF behavior.
    /// Range:         [0,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            tolFarTargetUpperBound;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// tolFarTargetLowerBound
    ///
    /// Description:   Lower bound ratio with respect to golden module K value as target is at far end (INFINITY). If estimated
    ///                K is within the bound, this means K value is valid for proper AF behavior.
    /// Range:         [0,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            tolFarTargetLowerBound;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixTuningPostProcess
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixTuningPostProcess
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// biasVectorStrength
    ///
    /// Description:   Strength of bias to be applied to disparity vector for the case of repeating patterns.
    /// Range:         [0.0,0.4]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            biasVectorStrength;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// temporalFilterStaticWeight
    ///
    /// Description:   Weight of temporal filter while lens is not moving. Weight=1.0 disables temporal filter.
    /// Range:         [0.0,1.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            temporalFilterStaticWeight;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// temporalFilterDynamicWeight
    ///
    /// Description:   Weight of temporal filter while lens is moving. Weight=1.0 disables temporal filter.
    /// Range:         [0.0,1.0]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            temporalFilterDynamicWeight;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enableGridOverlap
    ///
    /// Description:   Enables PD statistics to be computed in overlapping grids.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::enable_flag_type enableGridOverlap;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// confIntegralWidth
    ///
    /// Description:   Tuning parameter for confidence level. Increasing this tuning increases confidence level.
    /// Range:         [24,32]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32            confIntegralWidth;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDRange
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixPDRange
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// from
    ///
    /// Description:   PD search range near limit.
    /// Range:         [-48,-16]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 from;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// to
    ///
    /// Description:   PD search range far limit.
    /// Range:         [16,32]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 to;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixTuningCorrelation
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixTuningCorrelation
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// minimumConfidenceLevel
    ///
    /// Description:   Minimum confidence level threshold for binary confidence flag provided to aut focus algorithms.
    /// Range:         [50,200]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            minimumConfidenceLevel;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// defocusConfidenceThreshold
    ///
    /// Description:   Minimum confidence level threshold for triggering PD computation on additional ROI for sparse PDAF
    ///                sensors.
    /// Range:         [50,200]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            defocusConfidenceThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PDRangeControl
    ///
    /// Description:   Tuning for Confident Range.
    /// Range:         [0.02,0.10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT            PDRangeControl;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// searchRange
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixPDRange searchRange;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// lcrSearchRange
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixPDRange lcrSearchRange;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixLCRRawType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class chromatixLCRRawType
{
    PDAF_BAYER_RAW = 0,
    PDAF_IDEAL_RAW = 1,
    PDAF_CAMIF_RAW = 2
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixLCRBinningMode
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class chromatixLCRBinningMode
{
    PDAF_LCR_BINNING_DEFAULT = 0,
    PDAF_LCR_BINNING_ALL     = 1,
    PDAF_LCR_BINNING_SHIELD  = 2
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDLIBPreprocessingFilterSettings
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixPDLIBPreprocessingFilterSettings
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// AECTrigger
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    afglobalelements::trigger_pt_type_aec AECTrigger;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// verticalMode
    ///
    /// Description:   Vertical skip for preprocessing. Use of 2 means process 1 row and skip 1 row.
    /// Range:         [1,32]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32               verticalMode;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// horizontalMode
    ///
    /// Description:   Horizontal skip for preprocessing. Use of 2 means process 2 columns to generate 1 column.
    /// Range:         [1,8]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32               horizontalMode;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// boxFilterLength
    ///
    /// Description:   Not used.
    /// Range:         [1,8]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32               boxFilterLength;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// antiAliasFilterThreshold
    ///
    /// Description:   Not used.
    /// Range:         [80,120]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32               antiAliasFilterThreshold;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixLCRFilterTrigger
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixLCRFilterTrigger
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// filterSet - Array
    /// Length:        3
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixPDLIBPreprocessingFilterSettings filterSet[3];
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixDPDFilterTrigger
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixDPDFilterTrigger
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// filterSet - Array
    /// Length:        3
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixPDLIBPreprocessingFilterSettings filterSet[3];
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixHDRChannelSelection
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class chromatixHDRChannelSelection
{
    DPD_HDR_AUTO_MODE  = 0,
    DPD_HDR_LONG_MODE  = 1,
    DPD_HDR_SHORT_MODE = 2
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixTuningHDRCfg
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixTuningHDRCfg
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// channelSelection
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixHDRChannelSelection channelSelection;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// longThreshold
    ///
    /// Description:   Selection of PD processing on long-exposure frame (1), short-exposure frame (2), or auto selection (0).
    /// Range:         [0,2]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                        longThreshold;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixSparsePDProcMode
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
enum class chromatixSparsePDProcMode
{
    SPARSE_PD_PROC_SIMPLE = 0,
    SPARSE_PD_PROC_LCR    = 1
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixTuningPreProcess
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixTuningPreProcess
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sparseProcessingMode
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixSparsePDProcMode sparseProcessingMode;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// HDR
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixTuningHDRCfg     HDR;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// boxFilterLength
    ///
    /// Description:   Box filter legenth for sparse PDAF sensors.
    /// Range:         [1,8]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                     boxFilterLength;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// antiAliasFilterThreshold
    ///
    /// Description:   Anti-aliasing filter threshold for sparse PDAF sensors.
    /// Range:         [80,120]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                     antiAliasFilterThreshold;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// filterTrigger
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixDPDFilterTrigger filterTrigger;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// lcrFilterTrigger
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixLCRFilterTrigger lcrFilterTrigger;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// lcrBinningMode
    ///
    /// Description:   This parameter specify LCR binning strategy.
    /// Range:         [0,2]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixLCRBinningMode   lcrBinningMode;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// lcrRawType
    ///
    /// Description:   This parameter specify raw data type for LCR virtual pixel generation.
    /// Range:         [0,2]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixLCRRawType       lcrRawType;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// lcrMaxBinningNum
    ///
    /// Description:   Max pixel number for generate the virtual center pixel for advanced sparse PD mode.
    /// Range:         [1,4]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                     lcrMaxBinningNum;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDLibType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixPDLibType
{
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Binary file symbol table entry ID
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 SymbolTableID;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// module_version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct module_versionStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;
        INT32 major_revision;
        INT32 minor_revision;
    } module_version;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// parameter_version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct parameter_versionStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;
        INT32 major_revision;
        INT32 minor_revision;
    } parameter_version;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// preProcess
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixTuningPreProcess   preProcess;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// correlation
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixTuningCorrelation  correlation;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// postProcess
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixTuningPostProcess  postProcess;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// adaptiveK
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixTuningAdaptiveK    adaptiveK;
    afglobalelements::enable_flag_type            enablePeripheralWindows;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// singleWindowProcessingLevel
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixTuningProcessLevel singleWindowProcessingLevel;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// gridProcessingLevel
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixTuningProcessLevel gridProcessingLevel;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PeripheralProcessing
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixTuningProcessLevel PeripheralProcessing;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixPDLibTypeClass
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class chromatixPDLibTypeClass : public ParameterModule, public chromatixPDLibType
{
public:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static const UINT16 MAJOR = 3;
    static const UINT16 MINOR = 4;
    static const UINT32 PATCH = 0;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Default Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixPDLibTypeClass(
        const CHAR* name);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixPDLibTypeClass(
        const CHAR* name,
        UINT32 modeId,
        UINT16 mode,
        UINT16 subMode,
        UINT32 group);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Destructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ~chromatixPDLibTypeClass();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetName
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static const CHAR* GetName(
        const CHAR* type);


    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixTuningProcessLevel
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixTuningProcessLevel(
        ParameterFileSymbolTableEntry* entry,
        chromatixTuningProcessLevel* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixTuningAdaptiveK
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixTuningAdaptiveK(
        ParameterFileSymbolTableEntry* entry,
        chromatixTuningAdaptiveK* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixTuningPostProcess
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixTuningPostProcess(
        ParameterFileSymbolTableEntry* entry,
        chromatixTuningPostProcess* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDRange
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDRange(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDRange* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixTuningCorrelation
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixTuningCorrelation(
        ParameterFileSymbolTableEntry* entry,
        chromatixTuningCorrelation* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDLIBPreprocessingFilterSettings
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDLIBPreprocessingFilterSettings(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDLIBPreprocessingFilterSettings* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixLCRFilterTrigger
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixLCRFilterTrigger(
        ParameterFileSymbolTableEntry* entry,
        chromatixLCRFilterTrigger* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixDPDFilterTrigger
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixDPDFilterTrigger(
        ParameterFileSymbolTableEntry* entry,
        chromatixDPDFilterTrigger* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixTuningHDRCfg
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixTuningHDRCfg(
        ParameterFileSymbolTableEntry* entry,
        chromatixTuningHDRCfg* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixTuningPreProcess
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixTuningPreProcess(
        ParameterFileSymbolTableEntry* entry,
        chromatixTuningPreProcess* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixPDLibType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixPDLibType(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDLibType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load module_versionStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL Loadmodule_versionStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDLibType::module_versionStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load parameter_versionStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL Loadparameter_versionStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixPDLibType::parameter_versionStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Parse symbol table entry, and return a new object
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ParameterModule* Parse(
        ParameterSetManager* manager,
        ParameterFileSymbolTableEntry* entry) const;

}; // End class chromatixPDLibTypeClass

AFPDLIBELEMENTS_NAMESPACE_END
#endif // AFPDLIBELEMENTS_H

